{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 机器学习练习-决策树\n",
    "\n",
    "实验要求：1，请将本实验中两处代码不完整的地方补充完整：2，如果出现graphviz问题，请尝试解决；3，对照本章ppt和本实验代码，理解决策树原理。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1．分类决策树模型是表示基于特征对实例进行分类的树形结构。决策树可以转换成一个**if-then**规则的集合，也可以看作是定义在特征空间划分上的类的条件概率分布。\n",
    "\n",
    "2．决策树学习旨在构建一个与训练数据拟合很好，并且复杂度小的决策树。因为从可能的决策树中直接选取最优决策树是NP完全问题。现实中采用启发式方法学习次优的决策树。\n",
    "\n",
    "决策树学习算法包括3部分：特征选择、树的生成和树的剪枝。常用的算法有ID3、\n",
    "C4.5和CART。\n",
    "\n",
    "3．特征选择的目的在于选取对训练数据能够分类的特征。特征选择的关键是其准则。常用的准则如下：\n",
    "\n",
    "（1）样本集合$D$对特征$A$的信息增益（ID3）\n",
    "\n",
    "\n",
    "$$g(D, A)=H(D)-H(D|A)$$\n",
    "\n",
    "$$H(D)=-\\sum_{k=1}^{K} \\frac{\\left|C_{k}\\right|}{|D|} \\log _{2} \\frac{\\left|C_{k}\\right|}{|D|}$$\n",
    "\n",
    "$$H(D | A)=\\sum_{i=1}^{n} \\frac{\\left|D_{i}\\right|}{|D|} H\\left(D_{i}\\right)$$\n",
    "\n",
    "其中，$H(D)$是数据集$D$的熵，$H(D_i)$是数据集$D_i$的熵，$H(D|A)$是数据集$D$对特征$A$的条件熵。\t$D_i$是$D$中特征$A$取第$i$个值的样本子集，$C_k$是$D$中属于第$k$类的样本子集。$n$是特征$A$取 值的个数，$K$是类的个数。\n",
    "\n",
    "（2）样本集合$D$对特征$A$的信息增益比（C4.5）\n",
    "\n",
    "\n",
    "$$g_{R}(D, A)=\\frac{g(D, A)}{H(D)}$$\n",
    "\n",
    "\n",
    "其中，$g(D,A)$是信息增益，$H(D)$是数据集$D$的熵。\n",
    "\n",
    "（3）样本集合$D$的基尼指数（CART）\n",
    "\n",
    "$$\\operatorname{Gini}(D)=1-\\sum_{k=1}^{K}\\left(\\frac{\\left|C_{k}\\right|}{|D|}\\right)^{2}$$\n",
    "\n",
    "特征$A$条件下集合$D$的基尼指数：\n",
    "\n",
    " $$\\operatorname{Gini}(D, A)=\\frac{\\left|D_{1}\\right|}{|D|} \\operatorname{Gini}\\left(D_{1}\\right)+\\frac{\\left|D_{2}\\right|}{|D|} \\operatorname{Gini}\\left(D_{2}\\right)$$\n",
    " \n",
    "4．决策树的生成。通常使用信息增益最大、信息增益比最大或基尼指数最小作为特征选择的准则。决策树的生成往往通过计算信息增益或其他指标，从根结点开始，递归地产生决策树。这相当于用信息增益或其他准则不断地选取局部最优的特征，或将训练集分割为能够基本正确分类的子集。\n",
    "\n",
    "5．决策树的剪枝。由于生成的决策树存在过拟合问题，需要对它进行剪枝，以简化学到的决策树。决策树的剪枝，往往从已生成的树上剪掉一些叶结点或叶结点以上的子树，并将其父结点或根结点作为新的叶结点，从而简化生成的决策树。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "from math import log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Looking in indexes: https://mirrors.aliyun.com/pypi/simple\n",
      "Requirement already satisfied: graphviz in c:\\users\\12309\\appdata\\roaming\\python\\python311\\site-packages (0.20.3)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install graphviz -i https://mirrors.aliyun.com/pypi/simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Looking in indexes: https://mirrors.aliyun.com/pypi/simple\n",
      "Requirement already satisfied: scikit-learn in c:\\programdata\\anaconda3\\lib\\site-packages (1.2.2)\n",
      "Requirement already satisfied: numpy>=1.17.3 in c:\\programdata\\anaconda3\\lib\\site-packages (from scikit-learn) (1.24.3)\n",
      "Requirement already satisfied: scipy>=1.3.2 in c:\\programdata\\anaconda3\\lib\\site-packages (from scikit-learn) (1.10.1)\n",
      "Requirement already satisfied: joblib>=1.1.1 in c:\\programdata\\anaconda3\\lib\\site-packages (from scikit-learn) (1.2.0)\n",
      "Requirement already satisfied: threadpoolctl>=2.0.0 in c:\\programdata\\anaconda3\\lib\\site-packages (from scikit-learn) (2.2.0)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install scikit-learn -i https://mirrors.aliyun.com/pypi/simple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_data():\n",
    "    datasets = [['青年', '否', '否', '一般', '否'],\n",
    "               ['青年', '否', '否', '好', '否'],\n",
    "               ['青年', '是', '否', '好', '是'],\n",
    "               ['青年', '是', '是', '一般', '是'],\n",
    "               ['青年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '好', '否'],\n",
    "               ['中年', '是', '是', '好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '好', '是'],\n",
    "               ['老年', '是', '否', '好', '是'],\n",
    "               ['老年', '是', '否', '非常好', '是'],\n",
    "               ['老年', '否', '否', '一般', '否'],\n",
    "               ]\n",
    "    labels = [u'年龄', u'有工作', u'有自己的房子', u'信贷情况', u'类别']\n",
    "    # 返回数据集和每个维度的名称\n",
    "    return datasets, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = pd.DataFrame(datasets, columns=labels) #请将本行代码补充完整"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>年龄</th>\n",
       "      <th>有工作</th>\n",
       "      <th>有自己的房子</th>\n",
       "      <th>信贷情况</th>\n",
       "      <th>类别</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>一般</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>中年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    年龄 有工作 有自己的房子 信贷情况 类别\n",
       "0   青年   否      否   一般  否\n",
       "1   青年   否      否    好  否\n",
       "2   青年   是      否    好  是\n",
       "3   青年   是      是   一般  是\n",
       "4   青年   否      否   一般  否\n",
       "5   中年   否      否   一般  否\n",
       "6   中年   否      否    好  否\n",
       "7   中年   是      是    好  是\n",
       "8   中年   否      是  非常好  是\n",
       "9   中年   否      是  非常好  是\n",
       "10  老年   否      是  非常好  是\n",
       "11  老年   否      是    好  是\n",
       "12  老年   是      否    好  是\n",
       "13  老年   是      否  非常好  是\n",
       "14  老年   否      否   一般  否"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集的熵（信息熵）\n",
    "def calc_ent(datasets):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 统计数据集中每个类别的出现次数\n",
    "    label_count = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本的标签\n",
    "        label = datasets[i][-1]\n",
    "        # 如果该类别不在label_count中，则添加到label_count中\n",
    "        if label not in label_count:\n",
    "            label_count[label] = 0\n",
    "        # 统计该类别的出现次数\n",
    "        label_count[label] += 1\n",
    "    # 计算熵\n",
    "    ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                for p in label_count.values()])\n",
    "    return ent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 条件熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集在指定特征上的条件熵\n",
    "def cond_ent(datasets, axis=0):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 使用字典feature_sets存储在指定特征上的不同取值对应的样本集合\n",
    "    feature_sets = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本在指定特征上的取值\n",
    "        feature = datasets[i][axis]\n",
    "        # 如果该取值不在feature_sets中，则添加到feature_sets中\n",
    "        if feature not in feature_sets:\n",
    "            feature_sets[feature] = []\n",
    "        # 将该样本添加到对应取值的样本集合中\n",
    "        feature_sets[feature].append(datasets[i])\n",
    "    # 计算条件熵\n",
    "    cond_ent = sum([(len(p) / data_length) * calc_ent(p)\n",
    "                    for p in feature_sets.values()])\n",
    "    return cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9709505944546686"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_ent(datasets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 信息增益"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算信息增益\n",
    "def info_gain(ent, cond_ent):\n",
    "    # 信息增益等于熵减去条件熵\n",
    "    return ent - cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用信息增益选择最佳特征作为根节点特征进行决策树的训练\n",
    "def info_gain_train(datasets):\n",
    "    # 计算特征的数量\n",
    "    count = len(datasets[0]) - 1\n",
    "    # 计算整个数据集的熵\n",
    "    ent = calc_ent(datasets)\n",
    "    # 存储每个特征的信息增益\n",
    "    best_feature = []\n",
    "    for c in range(count):\n",
    "        # 计算每个特征的条件熵\n",
    "        c_info_gain = info_gain(ent, cond_ent(datasets, axis=c))\n",
    "        # 将特征及其对应的信息增益存入best_feature列表中\n",
    "        best_feature.append((c, c_info_gain))\n",
    "        # 输出每个特征的信息增益\n",
    "        print('特征({}) 的信息增益为： {:.3f}'.format(labels[c], c_info_gain))\n",
    "    # 找到信息增益最大的特征\n",
    "    best_ = max(best_feature, key=lambda x: x[-1])\n",
    "    # 返回信息增益最大的特征作为根节点特征\n",
    "    return '特征({})的信息增益最大，选择为根节点特征'.format(labels[best_[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征(年龄) 的信息增益为： 0.083\n",
      "特征(有工作) 的信息增益为： 0.324\n",
      "特征(有自己的房子) 的信息增益为： 0.420\n",
      "特征(信贷情况) 的信息增益为： 0.363\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'特征(有自己的房子)的信息增益最大，选择为根节点特征'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info_gain_train(np.array(datasets))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 利用ID3算法生成决策树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义节点类 二叉树\n",
    "class Node:\n",
    "    def __init__(self, root=True, label=None, feature_name=None, feature=None):\n",
    "        self.root = root\n",
    "        self.label = label\n",
    "        self.feature_name = feature_name\n",
    "        self.feature = feature\n",
    "        self.tree = {}\n",
    "        self.result = {\n",
    "            'label:': self.label,\n",
    "            'feature': self.feature,\n",
    "            'tree': self.tree\n",
    "        }\n",
    "\n",
    "    def __repr__(self):\n",
    "        return '{}'.format(self.result)\n",
    "\n",
    "    def add_node(self, val, node):\n",
    "        self.tree[val] = node\n",
    "\n",
    "    def predict(self, features):\n",
    "        if self.root is True:\n",
    "            return self.label\n",
    "        return self.tree[features[self.feature]].predict(features)\n",
    "\n",
    "\n",
    "class DTree:\n",
    "    def __init__(self, epsilon=0.1):\n",
    "        self.epsilon = epsilon\n",
    "        self._tree = {}\n",
    "\n",
    "    # 熵\n",
    "    @staticmethod\n",
    "    def calc_ent(datasets):\n",
    "        data_length = len(datasets)\n",
    "        label_count = {}\n",
    "        for i in range(data_length):\n",
    "            label = datasets[i][-1]\n",
    "            if label not in label_count:\n",
    "                label_count[label] = 0\n",
    "            label_count[label] += 1\n",
    "        ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                    for p in label_count.values()])\n",
    "        return ent\n",
    "\n",
    "    # 经验条件熵\n",
    "    def cond_ent(self, datasets, axis=0):\n",
    "        data_length = len(datasets)\n",
    "        feature_sets = {}\n",
    "        for i in range(data_length):\n",
    "            feature = datasets[i][axis]\n",
    "            if feature not in feature_sets:\n",
    "                feature_sets[feature] = []\n",
    "            feature_sets[feature].append(datasets[i])\n",
    "        cond_ent = sum([(len(p) / data_length) * self.calc_ent(p)\n",
    "                        for p in feature_sets.values()])\n",
    "        return cond_ent\n",
    "\n",
    "    # 信息增益\n",
    "    @staticmethod\n",
    "    def info_gain(ent, cond_ent):\n",
    "        return ent - cond_ent\n",
    "\n",
    "    def info_gain_train(self, datasets):\n",
    "        count = len(datasets[0]) - 1\n",
    "        ent = self.calc_ent(datasets)\n",
    "        best_feature = []\n",
    "        for c in range(count):\n",
    "            c_info_gain = self.info_gain(ent, self.cond_ent(datasets, axis=c))\n",
    "            best_feature.append((c, c_info_gain))\n",
    "        # 比较大小\n",
    "        best_ = max(best_feature, key=lambda x: x[-1])\n",
    "        return best_\n",
    "\n",
    "    def train(self, train_data):\n",
    "        \"\"\"\n",
    "        input:数据集D(DataFrame格式)，特征集A，阈值eta\n",
    "        output:决策树T\n",
    "        \"\"\"\n",
    "        _, y_train, features = train_data.iloc[:, :\n",
    "                                               -1], train_data.iloc[:,\n",
    "                                                                    -1], train_data.columns[:\n",
    "                                                                                            -1]\n",
    "        # 1,若D中实例属于同一类Ck，则T为单节点树，并将类Ck作为结点的类标记，返回T\n",
    "        if len(y_train.value_counts()) == 1:\n",
    "            return Node(root=True, label=y_train.iloc[0])\n",
    "\n",
    "        # 2, 若A为空，则T为单节点树，将D中实例树最大的类Ck作为该节点的类标记，返回T\n",
    "        if len(features) == 0:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 3,计算最大信息增益 同5.1,Ag为信息增益最大的特征\n",
    "        max_feature, max_info_gain = self.info_gain_train(np.array(train_data))\n",
    "        max_feature_name = features[max_feature]\n",
    "\n",
    "        # 4,Ag的信息增益小于阈值eta,则置T为单节点树，并将D中是实例数最大的类Ck作为该节点的类标记，返回T\n",
    "        if max_info_gain < self.epsilon:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 5,构建Ag子集\n",
    "        node_tree = Node(\n",
    "            root=False, feature_name=max_feature_name, feature=max_feature)\n",
    "\n",
    "        feature_list = train_data[max_feature_name].value_counts().index\n",
    "        for f in feature_list:\n",
    "            sub_train_df = train_data.loc[train_data[max_feature_name] ==\n",
    "                                          f].drop([max_feature_name], axis=1)\n",
    "\n",
    "            # 6, 递归生成树\n",
    "            sub_tree = self.train(sub_train_df)\n",
    "            node_tree.add_node(f, sub_tree)\n",
    "\n",
    "        # pprint.pprint(node_tree.tree)\n",
    "        return node_tree\n",
    "\n",
    "    def fit(self, train_data):\n",
    "        self._tree = self.train(train_data)\n",
    "        return self._tree\n",
    "\n",
    "    def predict(self, X_test):\n",
    "        return self._tree.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()\n",
    "data_df = pd.DataFrame(datasets, columns=labels)\n",
    "dt = DTree()\n",
    "tree = dt.fit(data_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label:': None, 'feature': 2, 'tree': {'否': {'label:': None, 'feature': 1, 'tree': {'否': {'label:': '否', 'feature': None, 'tree': {}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'否'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.predict(['老年', '否', '否', '一般'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn实例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用Iris数据集，我们可以构建如下树："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data\n",
    "def create_data():\n",
    "    iris =load_iris() #请将本行代码补充完整       \n",
    "    df = pd.DataFrame(iris.data, columns=iris.feature_names)\n",
    "    df['label'] = iris.target\n",
    "    df.columns = [\n",
    "        'sepal length', 'sepal width', 'petal length', 'petal width', 'label'\n",
    "    ]\n",
    "    data = np.array(df.iloc[:100, [0, 1, -1]])\n",
    "    # print(data)\n",
    "    return data[:, :2], data[:, -1],iris.feature_names[0:2]\n",
    "\n",
    "\n",
    "X, y,feature_name= create_data()\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9666666666666667"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.tree import export_graphviz\n",
    "import graphviz\n",
    "from sklearn import tree\n",
    "\n",
    "clf = DecisionTreeClassifier()\n",
    "clf.fit(X_train, y_train,)\n",
    "\n",
    "clf.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一旦经过训练，就可以用 plot_tree函数绘制树："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0.5, 0.9, 'x[0] <= 5.45\\ngini = 0.498\\nsamples = 70\\nvalue = [37, 33]'),\n",
       " Text(0.25, 0.7, 'x[1] <= 2.75\\ngini = 0.193\\nsamples = 37\\nvalue = [33, 4]'),\n",
       " Text(0.125, 0.5, 'gini = 0.0\\nsamples = 3\\nvalue = [0, 3]'),\n",
       " Text(0.375, 0.5, 'x[0] <= 5.3\\ngini = 0.057\\nsamples = 34\\nvalue = [33, 1]'),\n",
       " Text(0.25, 0.3, 'gini = 0.0\\nsamples = 29\\nvalue = [29, 0]'),\n",
       " Text(0.5, 0.3, 'x[1] <= 3.2\\ngini = 0.32\\nsamples = 5\\nvalue = [4, 1]'),\n",
       " Text(0.375, 0.1, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 1]'),\n",
       " Text(0.625, 0.1, 'gini = 0.0\\nsamples = 4\\nvalue = [4, 0]'),\n",
       " Text(0.75, 0.7, 'x[1] <= 3.45\\ngini = 0.213\\nsamples = 33\\nvalue = [4, 29]'),\n",
       " Text(0.625, 0.5, 'gini = 0.0\\nsamples = 29\\nvalue = [0, 29]'),\n",
       " Text(0.875, 0.5, 'gini = 0.0\\nsamples = 4\\nvalue = [4, 0]')]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tree.plot_tree(clf) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以导出树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree_pic = export_graphviz(clf, out_file=\"mytree.pdf\")\n",
    "with open('mytree.pdf') as f:\n",
    "    dot_graph = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 12.2.1 (20241206.2353)\n",
       " -->\n",
       "<!-- Title: Tree Pages: 1 -->\n",
       "<svg width=\"454pt\" height=\"491pt\"\n",
       " viewBox=\"0.00 0.00 454.00 491.25\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 487.25)\">\n",
       "<title>Tree</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-487.25 450,-487.25 450,4 -4,4\"/>\n",
       "<!-- 0 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>0</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"277.5,-483.25 168.5,-483.25 168.5,-412.25 277.5,-412.25 277.5,-483.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-465.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 5.45</text>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-450.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.498</text>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-434.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 70</text>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-418.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [37, 33]</text>\n",
       "</g>\n",
       "<!-- 1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>1</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"213.75,-376.25 112.25,-376.25 112.25,-305.25 213.75,-305.25 213.75,-376.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-358.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 2.75</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-343.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.193</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-327.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 37</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-311.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [33, 4]</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;1 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>0&#45;&gt;1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M203.02,-411.79C198.37,-403.64 193.35,-394.86 188.49,-386.36\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"191.64,-384.82 183.64,-377.87 185.57,-388.29 191.64,-384.82\"/>\n",
       "<text text-anchor=\"middle\" x=\"176.31\" y=\"-395.25\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">True</text>\n",
       "</g>\n",
       "<!-- 8 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>8</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"333.75,-376.25 232.25,-376.25 232.25,-305.25 333.75,-305.25 333.75,-376.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-358.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 3.45</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-343.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.213</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-327.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 33</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-311.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [4, 29]</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;8 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>0&#45;&gt;8</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M242.98,-411.79C247.63,-403.64 252.65,-394.86 257.51,-386.36\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"260.43,-388.29 262.36,-377.87 254.36,-384.82 260.43,-388.29\"/>\n",
       "<text text-anchor=\"middle\" x=\"269.69\" y=\"-395.25\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">False</text>\n",
       "</g>\n",
       "<!-- 2 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>2</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"94,-261.38 0,-261.38 0,-206.13 94,-206.13 94,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 3</text>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 3]</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;2 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>1&#45;&gt;2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M124.37,-304.79C111.74,-293.35 97.71,-280.65 85.11,-269.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"87.54,-266.72 77.77,-262.61 82.84,-271.91 87.54,-266.72\"/>\n",
       "</g>\n",
       "<!-- 3 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>3</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"213.75,-269.25 112.25,-269.25 112.25,-198.25 213.75,-198.25 213.75,-269.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-251.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 5.3</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-236.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.057</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-220.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 34</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-204.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [33, 1]</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>1&#45;&gt;3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M163,-304.79C163,-297.17 163,-289 163,-281.02\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"166.5,-281.07 163,-271.07 159.5,-281.07 166.5,-281.07\"/>\n",
       "</g>\n",
       "<!-- 4 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>4</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"155.75,-154.38 54.25,-154.38 54.25,-99.13 155.75,-99.13 155.75,-154.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-137.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-121.33\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 29</text>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-105.58\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [29, 0]</text>\n",
       "</g>\n",
       "<!-- 3&#45;&gt;4 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>3&#45;&gt;4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M143.69,-197.79C137.79,-187.12 131.3,-175.36 125.34,-164.57\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"128.46,-162.98 120.56,-155.91 122.33,-166.36 128.46,-162.98\"/>\n",
       "</g>\n",
       "<!-- 5 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>5</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"268,-162.25 174,-162.25 174,-91.25 268,-91.25 268,-162.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-144.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 3.2</text>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-129.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.32</text>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-113.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 5</text>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-97.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [4, 1]</text>\n",
       "</g>\n",
       "<!-- 3&#45;&gt;5 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>3&#45;&gt;5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M182.31,-197.79C186.76,-189.73 191.56,-181.05 196.21,-172.63\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"199.27,-174.33 201.04,-163.89 193.14,-170.95 199.27,-174.33\"/>\n",
       "</g>\n",
       "<!-- 6 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>6</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"212,-55.25 118,-55.25 118,0 212,0 212,-55.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"165\" y=\"-37.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"165\" y=\"-22.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 1</text>\n",
       "<text text-anchor=\"middle\" x=\"165\" y=\"-6.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 1]</text>\n",
       "</g>\n",
       "<!-- 5&#45;&gt;6 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>5&#45;&gt;6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M200.94,-90.96C196.17,-82.68 191.06,-73.81 186.23,-65.45\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"189.31,-63.78 181.28,-56.87 183.25,-67.28 189.31,-63.78\"/>\n",
       "</g>\n",
       "<!-- 7 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>7</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"324,-55.25 230,-55.25 230,0 324,0 324,-55.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"277\" y=\"-37.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"277\" y=\"-22.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 4</text>\n",
       "<text text-anchor=\"middle\" x=\"277\" y=\"-6.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [4, 0]</text>\n",
       "</g>\n",
       "<!-- 5&#45;&gt;7 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>5&#45;&gt;7</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M241.06,-90.96C245.83,-82.68 250.94,-73.81 255.77,-65.45\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"258.75,-67.28 260.72,-56.87 252.69,-63.78 258.75,-67.28\"/>\n",
       "</g>\n",
       "<!-- 9 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>9</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"333.75,-261.38 232.25,-261.38 232.25,-206.13 333.75,-206.13 333.75,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 29</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 29]</text>\n",
       "</g>\n",
       "<!-- 8&#45;&gt;9 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>8&#45;&gt;9</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M283,-304.79C283,-294.56 283,-283.32 283,-272.91\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"286.5,-273.1 283,-263.1 279.5,-273.1 286.5,-273.1\"/>\n",
       "</g>\n",
       "<!-- 10 -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>10</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"446,-261.38 352,-261.38 352,-206.13 446,-206.13 446,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"399\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"399\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 4</text>\n",
       "<text text-anchor=\"middle\" x=\"399\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [4, 0]</text>\n",
       "</g>\n",
       "<!-- 8&#45;&gt;10 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>8&#45;&gt;10</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M321.63,-304.79C334.26,-293.35 348.29,-280.65 360.89,-269.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"363.16,-271.91 368.23,-262.61 358.46,-266.72 363.16,-271.91\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.sources.Source at 0x1f49a1a8710>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "graphviz.Source(dot_graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树回归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a random dataset\n",
    "rng = np.random.RandomState(1)\n",
    "X = np.sort(5 * rng.rand(80, 1), axis=0)\n",
    "y = np.sin(X).ravel()\n",
    "y[::5] += 3 * (0.5 - rng.rand(16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fit regression model\n",
    "regr_1 = DecisionTreeRegressor(max_depth=2)\n",
    "regr_2 = DecisionTreeRegressor(max_depth=5)\n",
    "regr_1.fit(X, y)\n",
    "regr_2.fit(X, y)\n",
    "\n",
    "# Predict\n",
    "X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]\n",
    "y_1 = regr_1.predict(X_test)\n",
    "y_2 = regr_2.predict(X_test)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure()\n",
    "plt.scatter(X, y, s=20, edgecolor=\"black\", c=\"darkorange\", label=\"data\")\n",
    "plt.plot(X_test, y_1, color=\"cornflowerblue\", label=\"max_depth=2\", linewidth=2)\n",
    "plt.plot(X_test, y_2, color=\"yellowgreen\", label=\"max_depth=5\", linewidth=2)\n",
    "plt.xlabel(\"data\")\n",
    "plt.ylabel(\"target\")\n",
    "plt.title(\"Decision Tree Regression\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn 的决策树参数"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "DecisionTreeClassifier(criterion=\"gini\",\n",
    "                 splitter=\"best\",\n",
    "                 max_depth=None,\n",
    "                 min_samples_split=2,\n",
    "                 min_samples_leaf=1,\n",
    "                 min_weight_fraction_leaf=0.,\n",
    "                 max_features=None,\n",
    "                 random_state=None,\n",
    "                 max_leaf_nodes=None,\n",
    "                 min_impurity_decrease=0.,\n",
    "                 min_impurity_split=None,\n",
    "                 class_weight=None,\n",
    "                 presort=False)\n",
    "\n",
    "参数含义：\n",
    "1.criterion:string, optional (default=\"gini\")\n",
    "            (1).criterion='gini',分裂节点时评价准则是Gini指数。\n",
    "            (2).criterion='entropy',分裂节点时的评价指标是信息增益。\n",
    "2.max_depth:int or None, optional (default=None)。指定树的最大深度。\n",
    "            如果为None，表示树的深度不限。直到所有的叶子节点都是纯净的，即叶子节点\n",
    "            中所有的样本点都属于同一个类别。或者每个叶子节点包含的样本数小于min_samples_split。\n",
    "3.splitter:string, optional (default=\"best\")。指定分裂节点时的策略。\n",
    "           (1).splitter='best',表示选择最优的分裂策略。\n",
    "           (2).splitter='random',表示选择最好的随机切分策略。\n",
    "4.min_samples_split:int, float, optional (default=2)。表示分裂一个内部节点需要的做少样本数。\n",
    "           (1).如果为整数，则min_samples_split就是最少样本数。\n",
    "           (2).如果为浮点数(0到1之间)，则每次分裂最少样本数为ceil(min_samples_split * n_samples)\n",
    "5.min_samples_leaf: int, float, optional (default=1)。指定每个叶子节点需要的最少样本数。\n",
    "           (1).如果为整数，则min_samples_split就是最少样本数。\n",
    "           (2).如果为浮点数(0到1之间)，则每个叶子节点最少样本数为ceil(min_samples_leaf * n_samples)\n",
    "6.min_weight_fraction_leaf:float, optional (default=0.)\n",
    "           指定叶子节点中样本的最小权重。\n",
    "7.max_features:int, float, string or None, optional (default=None).\n",
    "           搜寻最佳划分的时候考虑的特征数量。\n",
    "           (1).如果为整数，每次分裂只考虑max_features个特征。\n",
    "           (2).如果为浮点数(0到1之间)，每次切分只考虑int(max_features * n_features)个特征。\n",
    "           (3).如果为'auto'或者'sqrt',则每次切分只考虑sqrt(n_features)个特征\n",
    "           (4).如果为'log2',则每次切分只考虑log2(n_features)个特征。\n",
    "           (5).如果为None,则每次切分考虑n_features个特征。\n",
    "           (6).如果已经考虑了max_features个特征，但还是没有找到一个有效的切分，那么还会继续寻找\n",
    "           下一个特征，直到找到一个有效的切分为止。\n",
    "8.random_state:int, RandomState instance or None, optional (default=None)\n",
    "           (1).如果为整数，则它指定了随机数生成器的种子。\n",
    "           (2).如果为RandomState实例，则指定了随机数生成器。\n",
    "           (3).如果为None，则使用默认的随机数生成器。\n",
    "9.max_leaf_nodes: int or None, optional (default=None)。指定了叶子节点的最大数量。\n",
    "           (1).如果为None,叶子节点数量不限。\n",
    "           (2).如果为整数，则max_depth被忽略。\n",
    "10.min_impurity_decrease:float, optional (default=0.)\n",
    "         如果节点的分裂导致不纯度的减少(分裂后样本比分裂前更加纯净)大于或等于min_impurity_decrease，则分裂该节点。\n",
    "         加权不纯度的减少量计算公式为：\n",
    "         min_impurity_decrease=N_t / N * (impurity - N_t_R / N_t * right_impurity\n",
    "                            - N_t_L / N_t * left_impurity)\n",
    "         其中N是样本的总数，N_t是当前节点的样本数，N_t_L是分裂后左子节点的样本数，\n",
    "         N_t_R是分裂后右子节点的样本数。impurity指当前节点的基尼指数，right_impurity指\n",
    "         分裂后右子节点的基尼指数。left_impurity指分裂后左子节点的基尼指数。\n",
    "11.min_impurity_split:float\n",
    "         树生长过程中早停止的阈值。如果当前节点的不纯度高于阈值，节点将分裂，否则它是叶子节点。\n",
    "         这个参数已经被弃用。用min_impurity_decrease代替了min_impurity_split。\n",
    "12.class_weight:dict, list of dicts, \"balanced\" or None, default=None\n",
    "         类别权重的形式为{class_label: weight}\n",
    "         (1).如果没有给出每个类别的权重，则每个类别的权重都为1。\n",
    "         (2).如果class_weight='balanced'，则分类的权重与样本中每个类别出现的频率成反比。\n",
    "         计算公式为：n_samples / (n_classes * np.bincount(y))\n",
    "         (3).如果sample_weight提供了样本权重(由fit方法提供)，则这些权重都会乘以sample_weight。\n",
    "13.presort:bool, optional (default=False)\n",
    "        指定是否需要提前排序数据从而加速训练中寻找最优切分的过程。设置为True时，对于大数据集\n",
    "        会减慢总体的训练过程；但是对于一个小数据集或者设定了最大深度的情况下，会加速训练过程。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树调参"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入库\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn import datasets\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 4) (150,)\n"
     ]
    }
   ],
   "source": [
    "# 导入数据集\n",
    "X = datasets.load_iris()  # 以全部字典形式返回,有data,target,target_names三个键\n",
    "data = X.data\n",
    "target = X.target\n",
    "name = X.target_names\n",
    "x, y = datasets.load_iris(return_X_y=True)  # 能一次性取前2个\n",
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据分为训练集和测试集\n",
    "x_train, x_test, y_train, y_test = train_test_split(x,\n",
    "                                                    y,\n",
    "                                                    test_size=0.2,\n",
    "                                                    random_state=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最优分类器: {'criterion': 'gini', 'max_depth': 60, 'min_impurity_decrease': 0.2, 'min_samples_leaf': 5} 最优分数: 0.9416666666666665\n"
     ]
    }
   ],
   "source": [
    "# 用GridSearchCV寻找最优参数（字典）\n",
    "param = {\n",
    "    'criterion': ['gini'],\n",
    "    'max_depth': [30, 50, 60, 100],\n",
    "    'min_samples_leaf': [2, 3, 5, 10],\n",
    "    'min_impurity_decrease': [0.1, 0.2, 0.5]\n",
    "}\n",
    "grid = GridSearchCV(DecisionTreeClassifier(), param_grid=param, cv=6)\n",
    "grid.fit(x_train, y_train)\n",
    "print('最优分类器:', grid.best_params_, '最优分数:', grid.best_score_)  # 得到最优的参数和分值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 参考\n",
    "\n",
    "- https://github.com/fengdu78/lihang-code\n",
    "\n",
    "- 李航. 统计学习方法[M]. 北京: 清华大学出版社,2019.\n",
    "\n",
    "- https://scikit-learn.org"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
